package com.qiwx.pigeon.Utils;

import android.text.TextUtils;

import java.text.DecimalFormat;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class StringUtil {

    private static final String TAG = "StringUtil";

    /**
     * 判断给定字符串是否空白串。 空白串是指由空格、制表符、回车符、换行符组成的字符串 若输入字符串为null或空字符串，返回true
     *
     * @param input
     * @return boolean
     */
    public static boolean isEmpty(String input) {
        if (input == null || "".equals(input) || input.equals("null"))
            return true;

        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            if (c != ' ' && c != '\t' && c != '\r' && c != '\n') {
                return false;
            }
        }

        return true;
    }


    /**
     * 判断list是否为空
     *
     * @param list
     * @return boolean
     */
    @SuppressWarnings("rawtypes")
    public static boolean isEmpty(List list) {
        return list == null || list.size() == 0;
    }

//    /**
//     * 判断是否是手机号码
//     */
//    public static boolean isPhoneNumberValid(String phoneNumber) {
//        if (!TextUtils.isEmpty(phoneNumber) && phoneNumber.length() == 11) {
//            String substring = phoneNumber.substring(0, 1);
//            return !TextUtils.isEmpty(substring) && "1".equals(substring);
//        } else {
//            return false;
//        }
//    }


    /**
     * 判断是否是验证码
     */
    public static boolean isVerifiyCodeNumberValid(String code) {
        return !TextUtils.isEmpty(code) && code.length() == 4;
    }

    /**
     * 验证value为String时是否为空校验
     *
     * @param params
     * @return
     */
    public static boolean isEmpty(Map<String, String> params) {
        //因为公共参数Telephone可能为空字符串, 所以暂时注掉该段代码
//        if (params == null) return true;
//        if (params.size() == 0) return true;
//        for (String value : params.values()) {
//            if (TextUtils.isEmpty(value))
//                return true;
//        }
        return false;
    }

    /***
     * 判断是整数或者小数，小数点后保留两位
     * @param decimals
     * @return
     */
    public static boolean isDecimal(String decimals) {
        String regex = "^(?!0+(?:\\.0+)?$)(?:[1-9]\\d*|0)(?:\\.\\d{1,2})?$";
        return Pattern.matches(regex, decimals);
    }

    /***
     * 判断是不是整数
     * @param inte
     * @return
     */
    public static boolean isInteger(String inte) {
        if (TextUtils.isEmpty(inte))
            return false;
        String regex = "[0-9]+";
        return Pattern.matches(regex, inte);
    }


    /***
     * 将String转成int，如果不是数字转不了，返回-1
     * @param str
     * @return
     */
    public static int str2Integer(String str) {
        if (isInteger(str))
            return Integer.valueOf(str).intValue();
        else
            return -1;
    }

    /***
     * 元转成万元，小数点后保留两位
     * @param yuan
     * @return
     */
    public static String yuan2Wan(int yuan) {
        double doublePrice = yuan * 0.0001;
        return finalPrice(doublePrice);
    }

    public static String yuan2Wan(String yuan) {
        int y = 0;
        try {
            y = Integer.parseInt(yuan);
        } catch (NumberFormatException e) {
            LogUtil.e(TAG,"成交价转换错误！");
        }
        double doublePrice = y * 0.0001;
        return finalPrice(doublePrice);
    }

    private static String finalPrice(double price) {
        String value = df.format(price);
        // 处理极端情况，如果老数据是9999999四舍五入以后是1000.00万元
        // 对于这种情况返回“999.99”
        return Double.parseDouble(value) >= 1000.00 ? "999.99" : value;
    }

    /***
     * 万元转为元
     * @param wan
     * @return
     */
    public static String wan2Yuan(String wan) {
        Double value = 0.00;
        try {
            value = Double.parseDouble(wan);
        } catch (NumberFormatException e) {
            LogUtil.e("StringUtil", e.getLocalizedMessage());
        }
        return String.valueOf((int) (value * 10000));
    }


    private final static DecimalFormat df = new DecimalFormat("0.00");

    /**
     * 格式化成交价，小数点后保留两位小数
     *
     * @param number 成交价
     * @return 格式化后的成交价（100.00）
     */
    public static String formatPrice(int number) {
        return df.format(number);
    }

    /**
     * 格式化成交价，小数点后保留两位小数
     *
     * @param number 成交价
     * @return 格式化后的成交价（100.00）
     */
    public static String formatPrice(float number) {
        return df.format(number);
    }

    /**
     * 格式化成交价，小数点后保留两位小数
     *
     * @param number 成交价
     * @return 格式化后的成交价（100.00）
     */
    public static String formatPrice(double number) {
        return finalPrice(number);
    }

    /**
     * 校验车牌号
     */
    public static boolean isLicencePlate(String str) {
////        String carnumRegex = "^([\u4e00-\u9fa5A-Z]{1}[A-Z]{1}(([0-9A-HJ-NP-Z]{6})|([DF]([A-HJ-NP-Z0-9])[0-9]{4})))|([\u4e00-\u9fa5A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9\u4e00-\u9fa5]{1})$";
//        String carnumRegex = "^[\u4e00-\u9fa5]{1}[a-hj-np-zA-HJ-NP-Z]{1}[a-hj-np-zA-HJ-NP-Z_0-9]{4}[a-hj-np-zA-HJ-NP-Z_0-9_\u4e00-\u9fa5]{1}[a-hj-np-zA-HJ-NP-Z_0-9_\u4e00-\u9fa5]{0,1}$";
//        Pattern pattern = Pattern.compile(carnumRegex);
        Pattern pattern = Pattern.compile("^[\u4e00-\u9fa5]{1}[A-Z]{1}[A-Z_0-9]{5}$");
        Matcher matcher = pattern.matcher(str);
        return matcher.matches();
    }

    /**
     * 判断字符串中是否包含数字、字母
     * @param str
     * @return
     */
    public static boolean hasDigitOrLetter(String str){
        if(TextUtils.isEmpty(str)){
            return false;
        }
        Pattern pattern = Pattern.compile("[A-Za-z0-9]+");
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()){
            return true;
        }
        return false;
    }
}
